import axios from "axios";
import { message } from 'antd';
import { store } from '../store';
import { refreshTokenAsync, updateAccessToken } from '../store/userSlice';
let requestNum = 0;
let loadingInstance: any = null;
let isRefreshing = false;
let pendingRequests: Array<{
	config: any;
	resolve: (value: unknown) => void;
	reject: (reason?: any) => void;
}> = [];
// 显示加载进度条
const showInstance = () => {
	requestNum++
	if (!loadingInstance) {
		loadingInstance = message.loading('加载中', 0)
	}
}
// 隐藏加载进度条
const hideInstance = () => {
	requestNum--
	if (requestNum <= 0) {
		requestNum = 0
		if (loadingInstance) {
			message.destroy()
			loadingInstance = null
		}
	}
}
// 创建axios实例
const instance = axios.create({
	baseURL: '/api',
	timeout: 10000,
});
// 处理等待中的请求
const processQueue = (error: any = null) => {
	pendingRequests.forEach(({ config, resolve, reject }) => {
		if (error) {
			reject(error);
		} else {
			// 重新发送请求
			resolve(instance(config));
		}
	});
	// 清空队列
	pendingRequests = [];
};
// 请求拦截器
instance.interceptors.request.use(function (config) {
	showInstance();
	// 从Redux store获取token
	const state = store.getState();
	const token = state.user?.accessToken || localStorage.getItem('token');
	if (token) {
		config.headers.Authorization = `Bearer ${token}`;
	}
	return config;
}, function (error) {
	hideInstance();
	return Promise.reject(error);
});
// 响应拦截器
instance.interceptors.response.use(function (response) {
	hideInstance();
	
	// 检查业务状态码
	const data = response.data;
	if (data && data.code !== undefined && data.code !== 0 && data.code !== 200) {
		// 处理业务错误码
		message.error(data.message || `业务错误(${data.code})`);
		return Promise.reject(new Error(data.message || `业务错误(${data.code})`));
	}
	
	return response;
}, async function (error) {
	hideInstance();
	
	const originalRequest = error.config;
	
	// 处理HTTP错误状态码
	if (error.response) {
		const status = error.response.status;
		
		// 如果是401错误（未授权，token过期）且没有标记为重试过
		if (status === 401 && !originalRequest._retry) {
			// 标记该请求已经重试过，避免无限循环
			originalRequest._retry = true;
			
			// 如果已经在刷新token，则将请求加入队列
			if (isRefreshing) {
				return new Promise((resolve, reject) => {
					pendingRequests.push({
						config: originalRequest,
						resolve,
						reject
					});
				});
			}
			
			isRefreshing = true;
			
			try {
				// 调用RTK中的refreshToken
				const result = await store.dispatch(refreshTokenAsync()).unwrap();
				
				// 更新token
				if (result && result.accessToken) {
					// 更新store中的token
					store.dispatch(updateAccessToken(result.accessToken));
					
					// 更新当前请求的Authorization头
					originalRequest.headers.Authorization = `Bearer ${result.accessToken}`;
					
					// 处理队列中的请求
					processQueue();
					
					// 重新发送原始请求
					return instance(originalRequest);
				}
			} catch (refreshError) {
				// 刷新token失败，处理队列中的请求
				processQueue(refreshError);
				
				// 可能需要跳转到登录页或其他处理
				console.error('Token刷新失败，请重新登录', refreshError);
				message.error('登录已过期，请重新登录');
				
				// 这里可以添加跳转到登录页的逻辑
				// window.location.href = '/login';
			} finally {
				isRefreshing = false;
			}
		} 
		// 其他HTTP错误状态码处理
		else {
			switch (status) {
				case 400:
					message.error('请求参数错误');
					break;
				case 403:
					message.error('您没有权限访问该资源');
					break;
				case 404:
					message.error('请求的资源不存在');
					break;
				case 500:
					message.error('服务器内部错误');
					break;
				case 502:
					message.error('网关错误');
					break;
				case 503:
					message.error('服务不可用');
					break;
				case 504:
					message.error('网关超时');
					break;
				default:
					message.error(`请求失败(${status})`);
			}
		}
	} else if (error.request) {
		// 请求已发送但没有收到响应
		message.error('网络异常，请检查您的网络连接');
	} else {
		// 请求配置出错
		message.error('请求配置错误: ' + error.message);
	}
	
	return Promise.reject(error);
});
export default instance;